home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 August: Tool Chest / Dev.CD Aug 94.toast / Tool Chest / Interfaces / MPW Interfaces / PInterfaces / MoviesFormat.p < prev    next >
Encoding:
Text File  |  1993-09-17  |  11.9 KB  |  475 lines  |  [TEXT/MPS ]

  1.  
  2. {************************************************************
  3. Created: Monday, August 17, 1992 at 5:13 PM
  4.  MoviesFormat.p
  5.  Pascal Interface to the Macintosh Libraries
  6.  
  7.  
  8.  Copyright Apple Computer, Inc. 1991, 1992
  9.  All rights reserved
  10.  
  11. ************************************************************}
  12.  
  13. {$IFC UNDEFINED UsingIncludes}
  14. {$SETC UsingIncludes := 0}
  15. {$ENDC}
  16.  
  17. {$IFC NOT UsingIncludes}
  18.  UNIT MoviesFormat;
  19.  INTERFACE
  20. {$ENDC}
  21.  
  22. {$IFC UNDEFINED UsingMoviesFormat}
  23. {$SETC UsingMoviesFormat := 1}
  24.  
  25. {$I+}
  26. {$SETC MoviesFormatIncludes := UsingIncludes}
  27. {$SETC UsingIncludes := 1}
  28.  
  29. {$IFC UNDEFINED UsingMovies}
  30. {$I $$Shell(PInterfaces)Movies.p}
  31. {$ENDC}
  32. {$IFC UNDEFINED UsingImageCompression}
  33. {$I $$Shell(PInterfaces)ImageCompression.p}
  34. {$ENDC}
  35. {$SETC UsingIncludes := MoviesFormatIncludes}
  36.  
  37. CONST
  38. kMovieVersion = 0;                { version number of the format here described }
  39.  
  40.  
  41. {****************************************
  42. *
  43. *   General Types -
  44. *        These types are used in more than one of the
  45. *        directory types.
  46. *
  47. ****************************************}
  48.  
  49. { MoviesUserData is the type used for user data in movie and track directories }
  50.  
  51. TYPE
  52.  
  53. MoviesUserData = RECORD
  54.     size    :    LONGINT;         { size of this user data }
  55.     udType    :    LONGINT;         { type of user data  }
  56.     data    :    PACKED ARRAY[0..0] OF Byte;         { the user data } 
  57. END;
  58.  
  59. UserDataAtom = RECORD
  60.     size        :    LONGINT;    
  61.     atomType    :    LONGINT; 
  62.     userData    :    ARRAY[0..0] OF MoviesUserData;
  63. END;
  64.  
  65.  
  66. { MoviesDataDescription tells us where the data for the movie or track lives.
  67.    The data can follow the directory, be in the datafork of the same file as the directory resource,
  68.    be in the resource fork of the same file as the directory resource, be in another file in the 
  69.    data fork or resource fork, or require a specific bottleneck to fetch the data. }
  70.  
  71.  
  72. {***************************************
  73. *
  74. *   MediaDirectory information -
  75. *        The MediaDirectory is tightly coupled to the data.
  76. *
  77. ***************************************}
  78.  
  79. { The SampleDescriptionTable holds the SampleDescriptions needed to decompress chunks given the
  80.    SampleDescriptionID. There is a table per Media. }
  81.  
  82. {
  83. SampleDescription = RECORD
  84.     size        :    LONGINT;
  85.     dataFormat    :    LONGINT;
  86.     resvd1        :    LONGINT;
  87.     resvdA        :    INTEGER;
  88.     dataRefId    :    INTEGER;
  89. END;
  90. SampleDescriptionHandle = ^^SampleDescription;
  91. }
  92.  
  93. SampleDescriptionAtom = RECORD
  94.     size            :    LONGINT;
  95.     atomType        :    LONGINT;            { = 'stsd' }
  96.     flags            :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  97.     numEntries        :    LONGINT;
  98.     sampleDescTable    :    ARRAY[0..0] OF SampleDescription;
  99. END;
  100.  
  101. { TimeToSampleNum maps physical sample time to physical sample number. }
  102.  
  103. TimeToSampleNum = RECORD
  104.     sampleCount     :    LONGINT;
  105.     sampleDuration    :    TimeValue;
  106. END;
  107.  
  108. TimeToSampleNumAtom = RECORD
  109.     size        :    LONGINT;
  110.     atomType    :    LONGINT;            { = 'stts' }
  111.     flags        :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  112.     numEntries    :    LONGINT;
  113.     timeToSampleNumTable : ARRAY[0..0] OF TimeToSampleNum;
  114. END;
  115.  
  116. { SyncSamples is a list of the physical samples which are self contained. }
  117.  
  118. SyncSampleAtom = RECORD
  119.     size            :    LONGINT;
  120.     atomType        :    LONGINT;        { = 'stss' }
  121.     flags            :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  122.     numEntries        :    LONGINT;
  123.     syncSampleTable    :    ARRAY[0..0] OF LONGINT;
  124. END;
  125.  
  126. SampleToChunk = RECORD
  127.     firstChunk            :    LONGINT;
  128.     samplesPerChunk        :    LONGINT;
  129.     sampleDescriptionID    :    LONGINT;
  130. END;
  131.  
  132. SampleToChunkAtom = RECORD
  133.     size                :    LONGINT;        
  134.     atomType            :    LONGINT;    { = 'stsc' }
  135.     flags                :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  136.     numEntries            :    LONGINT;        
  137.     sampleToChunkTable     :    ARRAY[0..0] OF SampleToChunk;
  138. END;
  139.  
  140. ChunkOffsetAtom = RECORD
  141.     size                :    LONGINT;    
  142.     atomType            :    LONGINT;                { = 'stco' }
  143.     flags                :    LONGINT;                { 1 byte of version / 3 bytes of flags }
  144.     numEntries            :    LONGINT;    
  145.     chunkOffsetTable    :    ARRAY[0..0] OF LONGINT;
  146. END;
  147.  
  148. SampleSizeAtom = RECORD
  149.     size            :    LONGINT;        
  150.     atomType        :    LONGINT;        { = 'stsz' }
  151.     flags            :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  152.     sampleSize        :    LONGINT;        
  153.     numEntries        :    LONGINT;        
  154.     sampleSizeTable :    ARRAY[0..0] OF LONGINT;
  155. END;
  156.  
  157. ShadowSync = RECORD
  158.     fdSampleNum        :    LONGINT;
  159.     syncSampleNum     :    LONGINT;
  160. END;
  161.  
  162. ShadowSyncAtom = RECORD
  163.     size            :    LONGINT;
  164.     atomType        :    LONGINT;
  165.     flags            :    LONGINT;
  166.     numEntries        :    LONGINT;
  167.     shadowSyncTable    :    ARRAY[0..0] OF ShadowSync;
  168. END;
  169.  
  170. SampleTableAtom = RECORD
  171.     size                :    LONGINT;    
  172.     atomType            :    LONGINT;        { = 'stbl' }
  173.     sampleDescription    :    SampleDescriptionAtom;
  174.     timeToSampleNum        :    TimeToSampleNumAtom;
  175.     sampleToChunk        :    SampleToChunkAtom;
  176.     syncSample            :    SyncSampleAtom;
  177.     sampleSize            :    SampleSizeAtom;
  178.     chunkOffset            :    ChunkOffsetAtom;
  179.     shadowSync            :    ShadowSyncAtom;
  180. END;
  181.  
  182. PublicHandlerInfo = RECORD
  183.     flags                    :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  184.     componentType            :    LONGINT;            
  185.     componentSubType        :    LONGINT;                
  186.     componentManufacturer    :    LONGINT;                
  187.     componentFlags            :    LONGINT;                
  188.     componentFlagsMask        :    LONGINT;                
  189.     componentName            :    PACKED ARRAY[0..0] OF Byte;
  190. END;
  191.     
  192. HandlerAtom = RECORD
  193.     size        :    LONGINT;        
  194.     atomType    :    LONGINT;        { = 'hdlr' }
  195.     hInfo        :    PublicHandlerInfo;    
  196. END;
  197.     
  198. DataRefAtom = LONGINT;
  199.  
  200. DataInfoAtom = RECORD
  201.     size        :    LONGINT;        
  202.     atomType    :    LONGINT;            { = 'dinf' }
  203.     dataRef        :    DataRefAtom;
  204. END;
  205.  
  206. RgnAtom = RECORD
  207.     size        :    LONGINT;        
  208.     atomType    :    LONGINT;        
  209.     rgnSize        :    INTEGER;        { this is the contents of a region }
  210.     rgnBBox        :    Rect;
  211.     data        :    ARRAY[0..0] OF Byte;
  212. END;
  213.  
  214. MatteCompressedAtom = RECORD
  215.     size        :    LONGINT;                
  216.     atomType    :    LONGINT;                
  217.     flags        :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  218.     matteImageDescription     :     ImageDescription;
  219.     matteData                 :    PACKED ARRAY[0..0] OF Byte;
  220. END;
  221.  
  222. MatteAtom = RECORD
  223.     size                :    LONGINT;                
  224.     atomType            :    LONGINT;            
  225.     aCompressedMatte    :    MatteCompressedAtom;
  226. END;
  227.  
  228. ClippingAtom = RECORD
  229.     size        :    LONGINT;    
  230.     atomType    :    LONGINT;        
  231.     aRgnClip    :    RgnAtom;
  232. END;
  233.     
  234. {***********************
  235. * Media Info Example Structures 
  236. ***********************}    
  237.  
  238. VideoMediaInfoHeader = RECORD
  239.     flags            :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  240.     graphicsMode    :    INTEGER;        { for QD - transfer mode }
  241.     opColorRed        :    INTEGER;        { opcolor for transfer mode }
  242.     opColorGreen    :    INTEGER;
  243.     opColorBlue        :    INTEGER;
  244. END;
  245.  
  246. VideoMediaInfoHeaderAtom = RECORD
  247.     size        :    LONGINT;                { size of Media info }
  248.     atomType    :    LONGINT;                { = 'vmhd' }
  249.     vmiHeader    :    VideoMediaInfoHeader;
  250. END;
  251.  
  252. VideoMediaInfo = RECORD
  253.     size        :    LONGINT;            { size of Media info }
  254.     atomType    :    LONGINT;            { = 'minf' }
  255.     header        :    VideoMediaInfoHeaderAtom;
  256.     dataHandler    :    HandlerAtom;
  257.     dataInfo    :    DataInfoAtom;
  258.     sampleTable    :    SampleTableAtom;
  259. END;
  260.  
  261. SoundMediaInfoHeader = RECORD
  262.     flags    :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  263.     balance    :    INTEGER;                
  264.     rsrvd    :    INTEGER;
  265. END;
  266.  
  267. SoundMediaInfoHeaderAtom = RECORD
  268.     size        :    LONGINT;            { size of Media info }
  269.     atomType    :    LONGINT;            { = 'vmhd' }
  270.     smiHeader    :    SoundMediaInfoHeader;    
  271. END;
  272.  
  273. SoundMediaInfo = RECORD
  274.     size            :    LONGINT;        { size of Media info }
  275.     atomType        :    LONGINT;        { = 'minf' }
  276.     header            :    SoundMediaInfoHeaderAtom;
  277.     dataHandler        :    HandlerAtom;
  278.     dataReference    :    DataRefAtom;
  279.     sampleTable        :    SampleTableAtom;
  280. END;
  281.  
  282. MediaInfo = RECORD
  283.     size        :    LONGINT;    
  284.     atomType    :    LONGINT;    
  285.     { whatever data the media handler needs goes here }
  286. END;
  287.  
  288.  
  289. {**********************
  290. * Media Directory Structures 
  291. **********************}    
  292.  
  293. MediaHeader = RECORD
  294.     flags                :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  295.     creationTime        :    LONGINT;    { seconds since Jan 1904 when directory was created }
  296.     modificationTime    :    LONGINT;    { seconds since Jan 1904 when directory was appended }
  297.     timeScale            :    TimeValue;    { start time for Media (Media time) }
  298.     duration            :    TimeValue;    { length of Media (Media time) }
  299.     language            :    INTEGER;
  300.     quality                :    INTEGER;
  301. END;
  302.  
  303. MediaHeaderAtom = RECORD
  304.     size        :    LONGINT;         
  305.     atomType    :    LONGINT;                
  306.     header        :    MediaHeader;
  307. END;
  308.  
  309. MediaDirectory = RECORD
  310.     size            :    LONGINT;
  311.     atomType        :    LONGINT;            { = 'mdia' }
  312.     mediaHeader     :     MediaHeaderAtom;    { standard Media information }
  313.     mHandler         :     HandlerAtom;
  314.     mediaInfo        :    MediaInfo;
  315. END;
  316.  
  317. {**********************
  318. * Track Structures 
  319. **********************}    
  320.  
  321. CONST    
  322.     TrackEnable     = 1;
  323.     TrackInMovie     = 2;
  324.     TrackInPreview     = 4;
  325.     TrackInPoster     = 8;
  326.     
  327. TYPE    
  328. TrackHeader = RECORD
  329.     flags            :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  330.     creationTime    :    LONGINT;    { seconds since Jan 1904 when directory was created }
  331.     modificationTime :    LONGINT;    { seconds since Jan 1904 when directory was appended }
  332.     trackID            :    LONGINT;
  333.     reserved1        :    LONGINT;
  334.     duration        :    TimeValue;    { length of track (track time) }
  335.     reserved2        :    LONGINT;
  336.     reserved3        :    LONGINT;
  337.     layer            :    INTEGER;
  338.     alternateGroup    :    INTEGER;
  339.     volume            :    INTEGER;
  340.     reserved4        :    INTEGER;
  341.     matrix            :    MatrixRecord;
  342.     trackWidth        :    Fixed;
  343.     trackHeight        :    Fixed;
  344. END;
  345.  
  346. TrackHeaderAtom = RECORD 
  347.     size        :    LONGINT;    { size of track header }
  348.     atomType    :    LONGINT;    { = 'tkhd' }
  349.     header        :    TrackHeader;
  350. END;
  351.  
  352. EditListType = RECORD 
  353.     trackDuration     :     TimeValue;
  354.     mediaTime        :    TimeValue;
  355.     mediaRate        :    Fixed;
  356. END;
  357.  
  358. EditListAtom    =    RECORD
  359.     size            :    LONGINT;
  360.     atomType        :    LONGINT;     { = elst }
  361.     flags            :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  362.     numEntries        :    LONGINT;
  363.     editListTable     :     ARRAY[0..0] OF EditListType;
  364. END;
  365.  
  366. EditsAtom = RECORD
  367.     size        :    LONGINT;
  368.     atomType    :    LONGINT;    { = edts }
  369.     editList    :    EditListAtom;
  370. END;
  371.  
  372. TrackDirectory = RECORD
  373.     size            :    LONGINT;
  374.     atomType        :    LONGINT;            { = 'trak' }
  375.     trackHeader        :    TrackHeaderAtom;    { standard track information }
  376.     trackClip        :    ClippingAtom;
  377.     edits            :    EditsAtom;
  378.     media            :    MediaDirectory;
  379.      userData        :    UserDataAtom;        { space for extending with new data types }
  380. END;
  381.  
  382. MovieHeader = RECORD
  383.     flags                :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  384.     creationTime        :    LONGINT;        { seconds since Jan 1904 when directory was created }
  385.     modificationTime     :    LONGINT;        { seconds since Jan 1904 when directory was appended }
  386.  
  387.     { Time specifications }
  388.     timeScale        :    TimeValue;
  389.     duration        :    TimeValue;
  390.     
  391.     preferredRate    :    Fixed;            { rate at which to play this movie }
  392.     preferredVolume    :    INTEGER;        { volume to play movie at }
  393.     reserved1        :    INTEGER;            
  394.  
  395.     { Graphics specifications }
  396.     reserved2            :    LONGINT;                    
  397.     reserved3            :    LONGINT;                    
  398.  
  399.     matrix                :    MatrixRecord;
  400.     
  401.     previewTime            :    TimeValue;        { time in track the proxy begins (track time) }
  402.     previewDuration        :    TimeValue;        { how long the proxy lasts (track time) }
  403.     posterTime             :    TimeValue;        { time in track the proxy begins (track time) }
  404.     selectionTime        :    TimeValue;        { time in track the proxy begins (track time) }
  405.     selectionDuration    :    TimeValue;        { time in track the proxy begins (track time) }
  406.     currentTime            :    TimeValue;        { time in track the proxy begins (track time) }
  407.     nextTrackID            :    LONGINT;        { next value to use for a TrackID }
  408. END;
  409.  
  410. MovieHeaderAtom = RECORD
  411.     size        :    LONGINT;
  412.     atomType    :    LONGINT;                        { = 'mvhd' }
  413.     header        :    MovieHeader;
  414. END;
  415.  
  416. MovieDirectory = RECORD
  417.     size        :    LONGINT;
  418.     atomType    :    LONGINT;                        { = 'moov' }
  419.     header        :    MovieHeaderAtom;
  420.     movieClip    :    ClippingAtom;                
  421.     { Track Directories }
  422.     track        :    RECORD
  423.                     trackDirectory : ARRAY[0..0] OF TrackDirectory;
  424.                      END;
  425.      { User data for Movie }
  426.      userData    :    UserDataAtom;                    { space for user extensions }
  427. END;
  428.  
  429. CONST
  430. { Movie formats and tags }
  431.     { some system defined format IDs }
  432.     MOVIE_TYPE    =    'moov';
  433.     TRACK_TYPE    =    'trak';
  434.     MEDIA_TYPE    =    'mdia';
  435.     VIDEO_TYPE    =    'vide';
  436.     SOUND_TYPE    =    'soun';
  437.  
  438. { atom id's }
  439.     MovieAID                =    'moov';
  440.     MovieHeaderAID            =    'mvhd';
  441.     ClipAID                    =    'clip';
  442.     RgnClipAID                =    'crgn';
  443.     MatteAID                =    'matt';
  444.     MatteCompAID            =    'kmat';
  445.     TrackAID                =    'trak';
  446.     UserDataAID                =    'udta';
  447.     TrackHeaderAID            =    'tkhd';
  448.     EditsAID                =    'edts';
  449.     EditListAID                =    'elst';
  450.     MediaAID                =    'mdia';
  451.     MediaHeaderAID            =    'mdhd';
  452.     MediaInfoAID            =    'minf';
  453.     VideoMediaInfoHeaderAID    =    'vmhd';
  454.     SoundMediaInfoHeaderAID    =    'smhd';
  455.     BaseMediaInfoHeaderAID     =     'gmhd';
  456.     BaseMediaInfoAID        =    'gmin';
  457.     DataInfoAID                =    'dinf';
  458.     DataRefAID                =    'dref';
  459.     SampleTableAID            =    'stbl';
  460.     STSampleDescAID            =    'stsd';
  461.     STTimeToSampAID            =    'stts';
  462.     STSyncSampleAID            =    'stss';
  463.     STSampleToChunkAID        =    'stsc';
  464.     STShadowSyncAID            =    'stsh';
  465.     HandlerAID                =    'hdlr';
  466.     STSampleSizeAID            =    'stsz';
  467.     STChunkOffsetAID        =    'stco';
  468.     DataRefContainerAID     =    'drfc';
  469.     
  470. {$ENDC} { UsingMoviesFormat }
  471.  
  472. {$IFC NOT UsingIncludes}
  473.  END.
  474. {$ENDC}
  475.